[Chapter Sixteen][Previous]
[Next] [Art of
Assembly][Randall Hyde]
Art of Assembly: Chapter Sixteen
- 16.8.4 - A Tiny Assembler
16.8.4 A Tiny Assembler
Although the UCR Standard Library pattern matching routines would probably
not be appropriate for writing a full lexical analyzer or compiler, they
are useful for writing small compilers/assemblers or programs where speed
of compilation/assembly is of little concern. One good example is the simple
nonsymbolic assembler appearing in the SIM886 simulator for an earlier version
of the x86 processors. This "mini-assembler" accepts an x86 assembly
language statement and immediately assembles it into memory. This allows
SIM886 users to create simple assembly language programs within the SIM886
monitor/debugger. Using the Standard Library pattern matching routines makes
it very easy to implement such an assembler.
The grammar for this miniassembler is
Stmt 
Grp1 reg "," operand |
Grp2 reg "," reg "," constant |
Grp3 operand |
goto operand |
halt
Grp1 load | store | add | sub
Grp2 ifeq | iflt | ifgt
Grp3 get | put
reg ax | bx | cx | dx
operand reg | constant | [bx] | constant [bx]
constant hexdigit constant | hexdigit
hexdigit 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | a | b |
c | d | e | f
There are some minor semantic details that the program handles (such as
disallowing stores into immediate operands). The assembly code for the miniassembler
follows:
; ASM.ASM
;
.xlist
include stdlib.a
matchfuncs
includelib stdlib.lib
.list
dseg segment para public 'data'
; Some sample statements to assemble:
Str1 byte "load ax, 0",0
Str2 byte "load ax, bx",0
Str3 byte "load ax, ax",0
Str4 byte "add ax, 15",0
Str5 byte "sub ax, [bx]",0
Str6 byte "store bx, [1000]",0
Str7 byte "load bx, 2000[bx]",0
Str8 byte "goto 3000",0
Str9 byte "iflt ax, bx, 100",0
Str10 byte "halt",0
Str11 byte "This is illegal",0
Str12 byte "load ax, store",0
Str13 byte "store ax, 1000",0
Str14 byte "ifeq ax, 0, 0",0
; Variables used by the assembler.
AsmConst word 0
AsmOpcode byte 0
AsmOprnd1 byte 0
AsmOprnd2 byte 0
include stdsets.a ;Bring in the standard char sets.
; Patterns for the assembler:
; Pattern is (
; (load|store|add|sub) reg "," operand |
; (ifeq|iflt|ifgt) reg1 "," reg2 "," const |
; (get|put) operand |
; goto operand |
; halt
; )
;
; With a few semantic additions (e.g., cannot store to a const).
InstrPat pattern {spancset, WhiteSpace,Grp1,Grp1}
Grp1 pattern {sl_Match2,Grp1Strs, Grp2 ,Grp1Oprnds}
Grp1Strs pattern {TryLoad,,Grp1Store}
Grp1Store pattern {TryStore,,Grp1Add}
Grp1Add pattern {TryAdd,,Grp1Sub}
Grp1Sub pattern {TrySub}
; Patterns for the LOAD, STORE, ADD, and SUB instructions.
LoadPat pattern {MatchStr,LoadInstr2}
LoadInstr2 byte "LOAD",0
StorePat pattern {MatchStr,StoreInstr2}
StoreInstr2 byte "STORE",0
AddPat pattern {MatchStr,AddInstr2}
AddInstr2 byte "ADD",0
SubPat pattern {MatchStr,SubInstr2}
SubInstr2 byte "SUB",0
; Patterns for the group one (LOAD/STORE/ADD/SUB) instruction operands:
Grp1Oprnds pattern {spancset,WhiteSpace,Grp1reg,Grp1reg}
Grp1Reg pattern {MatchReg,AsmOprnd1,,Grp1ws2}
Grp1ws2 pattern {spancset,WhiteSpace,Grp1Comma,Grp1Comma}
Grp1Comma pattern {MatchChar,',',0,Grp1ws3}
Grp1ws3 pattern {spancset,WhiteSpace,Grp1Op2,Grp1Op2}
Grp1Op2 pattern {MatchGen,,,EndOfLine}
EndOfLine pattern {spancset,WhiteSpace,NullChar,NullChar}
NullChar pattern {EOS}
Grp1Op2Reg pattern {MatchReg,AsmOprnd2}
; Patterns for the group two instructions (IFEQ, IFLT, IFGT):
Grp2 pattern {sl_Match2,Grp2Strs, Grp3 ,Grp2Oprnds}
Grp2Strs pattern {TryIFEQ,,Grp2IFLT}
Grp2IFLT pattern {TryIFLT,,Grp2IFGT}
Grp2IFGT pattern {TryIFGT}
Grp2Oprnds pattern {spancset,WhiteSpace,Grp2reg,Grp2reg}
Grp2Reg pattern {MatchReg,AsmOprnd1,,Grp2ws2}
Grp2ws2 pattern {spancset,WhiteSpace,Grp2Comma,Grp2Comma}
Grp2Comma pattern {MatchChar,',',0,Grp2ws3}
Grp2ws3 pattern {spancset,WhiteSpace,Grp2Reg2,Grp2Reg2}
Grp2Reg2 pattern {MatchReg,AsmOprnd2,,Grp2ws4}
Grp2ws4 pattern {spancset,WhiteSpace,Grp2Comma2,Grp2Comma2}
Grp2Comma2 pattern {MatchChar,',',0,Grp2ws5}
Grp2ws5 pattern {spancset,WhiteSpace,Grp2Op3,Grp2Op3}
Grp2Op3 pattern {ConstPat,,,EndOfLine}
; Patterns for the IFEQ, IFLT, and IFGT instructions.
IFEQPat pattern {MatchStr,IFEQInstr2}
IFEQInstr2 byte "IFEQ",0
IFLTPat pattern {MatchStr,IFLTInstr2}
IFLTInstr2 byte "IFLT",0
IFGTPat pattern {MatchStr,IFGTInstr2}
IFGTInstr2 byte "IFGT",0
; Grp3 Patterns:
Grp3 pattern {sl_Match2,Grp3Strs, Grp4 ,Grp3Oprnds}
Grp3Strs pattern {TryGet,,Grp3Put}
Grp3Put pattern {TryPut,,Grp3GOTO}
Grp3Goto pattern {TryGOTO}
; Patterns for the GET and PUT instructions.
GetPat pattern {MatchStr,GetInstr2}
GetInstr2 byte "GET",0
PutPat pattern {MatchStr,PutInstr2}
PutInstr2 byte "PUT",0
GOTOPat pattern {MatchStr,GOTOInstr2}
GOTOInstr2 byte "GOTO",0
; Patterns for the group three (PUT/GET/GOTO) instruction operands:
Grp3Oprnds pattern {spancset,WhiteSpace,Grp3Op,Grp3Op}
Grp3Op pattern {MatchGen,,,EndOfLine}
; Patterns for the group four instruction (HALT).
Grp4 pattern {TryHalt,,,EndOfLine}
HaltPat pattern {MatchStr,HaltInstr2}
HaltInstr2 byte "HALT",0
; Patterns to match the four non-register addressing modes:
BXIndrctPat pattern {MatchStr,BXIndrctStr}
BXIndrctStr byte "[BX]",0
BXIndexedPat pattern {ConstPat,,,BXIndrctPat}
DirectPat pattern {MatchChar,'[',,DP2}
DP2 pattern {ConstPat,,,DP3}
DP3 pattern {MatchChar,']'}
ImmediatePat pattern {ConstPat}
; Pattern to match a hex constant:
HexConstPat pattern {Spancset, xdigits}
dseg ends
cseg segment para public 'code'
assume cs:cseg, ds:dseg
; The store macro tweaks the DS register and stores into the
; specified variable in DSEG.
store macro Where, What
push ds
push ax
mov ax, seg Where
mov ds, ax
mov Where, What
pop ax
pop ds
endm
; Pattern matching routines for the assembler.
; Each mnemonic has its own corresponding matching function that
; attempts to match the mnemonic. If it does, it initializes the
; AsmOpcode variable with the base opcode of the instruction.
; Compare against the "LOAD" string.
TryLoad proc far
push dx
push si
ldxi LoadPat
match2
jnc NoTLMatch
store AsmOpcode, 0 ;Initialize base opcode.
NoTLMatch: pop si
pop dx
ret
TryLoad endp
; Compare against the "STORE" string.
TryStore proc far
push dx
push si
ldxi StorePat
match2
jnc NoTSMatch
store AsmOpcode, 1 ;Initialize base opcode.
NoTSMatch: pop si
pop dx
ret
TryStore endp
; Compare against the "ADD" string.
TryAdd proc far
push dx
push si
ldxi AddPat
match2
jnc NoTAMatch
store AsmOpcode, 2 ;Initialize ADD opcode.
NoTAMatch: pop si
pop dx
ret
TryAdd endp
; Compare against the "SUB" string.
TrySub proc far
push dx
push si
ldxi SubPat
match2
jnc NoTMMatch
store AsmOpcode, 3 ;Initialize SUB opcode.
NoTMMatch: pop si
pop dx
ret
TrySub endp
; Compare against the "IFEQ" string.
TryIFEQ proc far
push dx
push si
ldxi IFEQPat
match2
jnc NoIEMatch
store AsmOpcode, 4 ;Initialize IFEQ opcode.
NoIEMatch: pop si
pop dx
ret
TryIFEQ endp
; Compare against the "IFLT" string.
TryIFLT proc far
push dx
push si
ldxi IFLTPat
match2
jnc NoILMatch
store AsmOpcode, 5 ;Initialize IFLT opcode.
NoILMatch: pop si
pop dx
ret
TryIFLT endp
; Compare against the "IFGT" string.
TryIFGT proc far
push dx
push si
ldxi IFGTPat
match2
jnc NoIGMatch
store AsmOpcode, 6 ;Initialize IFGT opcode.
NoIGMatch: pop si
pop dx
ret
TryIFGT endp
; Compare against the "GET" string.
TryGET proc far
push dx
push si
ldxi GetPat
match2
jnc NoGMatch
store AsmOpcode, 7 ;Initialize Special opcode.
store AsmOprnd1, 2 ;GET's Special opcode.
NoGMatch: pop si
pop dx
ret
TryGET endp
; Compare against the "PUT" string.
TryPut proc far
push dx
push si
ldxi PutPat
match2
jnc NoPMatch
store AsmOpcode, 7 ;Initialize Special opcode.
store AsmOprnd1, 3 ;PUT's Special opcode.
NoPMatch: pop si
pop dx
ret
TryPUT endp
; Compare against the "GOTO" string.
TryGOTO proc far
push dx
push si
ldxi GOTOPat
match2
jnc NoGMatch
store AsmOpcode, 7 ;Initialize Special opcode.
store AsmOprnd1, 1 ;PUT's Special opcode.
NoGMatch: pop si
pop dx
ret
TryGOTO endp
; Compare against the "HALT" string.
TryHalt proc far
push dx
push si
ldxi HaltPat
match2
jnc NoHMatch
store AsmOpcode, 7 ;Initialize Special opcode.
store AsmOprnd1, 0 ;Halt's special opcode.
store AsmOprnd2, 0
NoHMatch: pop si
pop dx
ret
TryHALT endp
; MatchReg checks to see if we've got a valid register value. On entry,
; DS:SI points at the location to store the byte opcode (0, 1, 2, or 3) for
; a reasonable register (AX, BX, CX, or DX); ES:DI points at the string
; containing (hopefully) the register operand, and CX points at the last
; location plus one we can check in the string.
;
; On return, Carry=1 for success, 0 for failure. ES:AX must point beyond
; the characters which make up the register if we have a match.
MatchReg proc far
; ES:DI Points at two characters which should be AX/BX/CX/DX. Anything
; else is an error.
cmp byte ptr es:1[di], 'X' ;Everyone needs this
jne BadReg
xor ax, ax ;886 "AX" reg code.
cmp byte ptr es:[di], 'A' ;AX?
je GoodReg
inc ax
cmp byte ptr es:[di], 'B' ;BX?
je GoodReg
inc ax
cmp byte ptr es:[di], 'C' ;CX?
je GoodReg
inc ax
cmp byte ptr es:[di], 'D' ;DX?
je GoodReg
BadReg: clc
mov ax, di
ret
GoodReg:
mov ds:[si], al ;Save register opcode.
lea ax, 2[di] ;Skip past register.
cmp ax, cx ;Be sure we didn't go
ja BadReg ; too far.
stc
ret
MatchReg endp
; MatchGen- Matches a general addressing mode. Stuffs the appropriate
; addressing mode code into AsmOprnd2. If a 16-bit constant
; is required by this addressing mode, this code shoves that
; into the AsmConst variable.
MatchGen proc far
push dx
push si
; Try a register operand.
ldxi Grp1Op2Reg
match2
jc MGDone
; Try "[bx]".
ldxi BXIndrctPat
match2
jnc TryBXIndexed
store AsmOprnd2, 4
jmp MGDone
; Look for an operand of the form "xxxx[bx]".
TryBXIndexed:
ldxi BXIndexedPat
match2
jnc TryDirect
store AsmOprnd2, 5
jmp MGDone
; Try a direct address operand "[xxxx]".
TryDirect:
ldxi DirectPat
match2
jnc TryImmediate
store AsmOprnd2, 6
jmp MGDone
; Look for an immediate operand "xxxx".
TryImmediate:
ldxi ImmediatePat
match2
jnc MGDone
store AsmOprnd2, 7
MGDone:
pop si
pop dx
ret
MatchGen endp
; ConstPat- Matches a 16-bit hex constant. If it matches, it converts
; the string to an integer and stores it into AsmConst.
ConstPat proc far
push dx
push si
ldxi HexConstPat
match2
jnc CPDone
push ds
push ax
mov ax, seg AsmConst
mov ds, ax
atoh
mov AsmConst, ax
pop ax
pop ds
stc
CPDone: pop si
pop dx
ret
ConstPat endp
; Assemble- This code assembles the instruction that ES:DI points
; at and displays the hex opcode(s) for that instruction.
Assemble proc near
; Print out the instruction we're about to assemble.
print
byte "Assembling: ",0
strupr
puts
putcr
; Assemble the instruction:
ldxi InstrPat
xor cx, cx
match
jnc SyntaxError
; Quick check for illegal instructions:
cmp AsmOpcode, 7 ;Special/Get instr.
jne TryStoreInstr
cmp AsmOprnd1, 2 ;GET opcode
je SeeIfImm
cmp AsmOprnd1, 1 ;Goto opcode
je IsGOTO
TryStoreInstr: cmp AsmOpcode, 1 ;Store Instruction
jne InstrOkay
SeeIfImm: cmp AsmOprnd2, 7 ;Immediate Adrs Mode
jne InstrOkay
print
db "Syntax error: store/get immediate not allowed."
db " Try Again",cr,lf,0
jmp ASMDone
IsGOTO: cmp AsmOprnd2, 7 ;Immediate mode for GOTO
je InstrOkay
print
db "Syntax error: GOTO only allows immediate "
byte "mode.",cr,lf
db 0
jmp ASMDone
; Merge the opcode and operand fields together in the instruction byte,
; then output the opcode byte.
InstrOkay: mov al, AsmOpcode
shl al, 1
shl al, 1
or al, AsmOprnd1
shl al, 1
shl al, 1
shl al, 1
or al, AsmOprnd2
puth
cmp AsmOpcode, 4 ;IFEQ instruction
jb SimpleInstr
cmp AsmOpcode, 6 ;IFGT instruction
jbe PutConstant
SimpleInstr: cmp AsmOprnd2, 5
jb ASMDone
; If this instruction has a 16 bit operand, output it here.
PutConstant: mov al, ' '
putc
mov ax, ASMConst
puth
mov al, ' '
putc
xchg al, ah
puth
jmp ASMDone
SyntaxError: print
db "Syntax error in instruction."
db cr,lf,0
ASMDone: putcr
ret
Assemble endp
; Main program that tests the assembler.
Main proc
mov ax, seg dseg ;Set up the segment registers
mov ds, ax
mov es, ax
meminit
lesi Str1
call Assemble
lesi Str2
call Assemble
lesi Str3
call Assemble
lesi Str4
call Assemble
lesi Str5
call Assemble
lesi Str6
call Assemble
lesi Str7
call Assemble
lesi Str8
call Assemble
lesi Str9
call Assemble
lesi Str10
call Assemble
lesi Str11
call Assemble
lesi Str12
call Assemble
lesi Str13
call Assemble
lesi Str14
call Assemble
Quit: ExitPgm
Main endp
cseg ends
sseg segment para stack 'stack'
stk db 256 dup ("stack ")
sseg ends
zzzzzzseg segment para public 'zzzzzz'
LastBytes db 16 dup (?)
zzzzzzseg ends
end Main
Sample Output:
Assembling: LOAD AX, 0
07 00 00
Assembling: LOAD AX, BX
01
Assembling: LOAD AX, AX
00
Assembling: ADD AX, 15
47 15 00
Assembling: SUB AX, [BX]
64
Assembling: STORE BX, [1000]
2E 00 10
Assembling: LOAD BX, 2000[BX]
0D 00 20
Assembling: GOTO 3000
EF 00 30
Assembling: IFLT AX, BX, 100
A1 00 01
Assembling: HALT
E0
Assembling: THIS IS ILLEGAL
Syntax error in instruction.
Assembling: LOAD AX, STORE
Syntax error in instruction.
Assembling: STORE AX, 1000
Syntax error: store/get immediate not allowed. Try Again
Assembling: IFEQ AX, 0, 0
Syntax error in instruction.
- 16.8.4 - A Tiny Assembler
Art of Assembly: Chapter Sixteen - 29 SEP 1996
[Chapter Sixteen][Previous]
[Next] [Art of
Assembly][Randall Hyde]